/**
 * 模型注册表 - 统一管理所有场景的3D模型资源
 */
export class ModelRegistry {
    constructor() {
        this.models = new Map();
        this.initializeModels();
    }
    
    /**
     * 初始化所有场景的模型配置
     */
    initializeModels() {
        // 几何场景 - 无需外部模型，使用程序化生成
        this.registerSceneModels('geometry', []);
        
        // 粒子场景 - 无需外部模型，使用程序化生成
        this.registerSceneModels('particle', []);
        
        // 模型场景 - 可以  添加一些示例模型
        this.registerSceneModels('model', [
            // 可以添加一些免费的GLTF模型URL
            // {
            //     id: 'example-model',
            //     url: 'https://example.com/model.gltf',
            //     name: '示例模型',
            //     size: 'large' // small, medium, large
            // }
        ]);
        
        // 汽车场景
        this.registerSceneModels('car', [
            {
                id: 'yuanqu',
                url: 'https://prod-ylzapp-public.oss-cn-zhangjiakou.aliyuncs.com/frontend/yun-material/user-upload/1735268832120_yuanqu.glb',
                name: '鲜生活配送车',
                size: 'large',
                description: '带有鲜生活标志的配送车辆模型'
            },
        ]);
        
        // 可以继续添加更多场景的模型
        // this.registerSceneModels('newScene', [...]);
    }
    
    /**
     * 注册场景的模型列表
     * @param {string} sceneId - 场景ID
     * @param {Array} models - 模型配置数组
     */
    registerSceneModels(sceneId, models) {
        this.models.set(sceneId, models);
        console.log(`已注册场景 ${sceneId} 的 ${models.length} 个模型`);
    }
    
    /**
     * 获取指定场景的模型列表
     * @param {string} sceneId - 场景ID
     * @returns {Array} 模型配置数组
     */
    getSceneModels(sceneId) {
        return this.models.get(sceneId) || [];
    }
    
    /**
     * 获取所有模型列表
     * @returns {Array} 所有模型的配置数组
     */
    getAllModels() {
        const allModels = [];
        for (const [sceneId, models] of this.models) {
            models.forEach(model => {
                allModels.push({
                    ...model,
                    sceneId
                });
            });
        }
        return allModels;
    }
    
    /**
     * 根据ID获取模型配置
     * @param {string} modelId - 模型ID
     * @returns {Object|null} 模型配置对象
     */
    getModelById(modelId) {
        for (const [sceneId, models] of this.models) {
            const model = models.find(m => m.id === modelId);
            if (model) {
                return { ...model, sceneId };
            }
        }
        return null;
    }
    
    /**
     * 添加新模型到指定场景
     * @param {string} sceneId - 场景ID
     * @param {Object} modelConfig - 模型配置
     */
    addModel(sceneId, modelConfig) {
        if (!this.models.has(sceneId)) {
            this.models.set(sceneId, []);
        }
        
        const models = this.models.get(sceneId);
        
        // 检查是否已存在相同ID的模型
        const existingIndex = models.findIndex(m => m.id === modelConfig.id);
        if (existingIndex >= 0) {
            models[existingIndex] = modelConfig;
            console.log(`更新模型: ${modelConfig.id}`);
        } else {
            models.push(modelConfig);
            console.log(`添加新模型: ${modelConfig.id}`);
        }
    }
    
    /**
     * 移除指定模型
     * @param {string} sceneId - 场景ID
     * @param {string} modelId - 模型ID
     */
    removeModel(sceneId, modelId) {
        if (!this.models.has(sceneId)) return;
        
        const models = this.models.get(sceneId);
        const index = models.findIndex(m => m.id === modelId);
        
        if (index >= 0) {
            models.splice(index, 1);
            console.log(`移除模型: ${modelId}`);
        }
    }
    
    /**
     * 获取模型统计信息
     * @returns {Object} 统计信息
     */
    getStatistics() {
        const stats = {
            totalScenes: this.models.size,
            totalModels: 0,
            modelsByScene: {},
            modelsBySize: { small: 0, medium: 0, large: 0 }
        };
        
        for (const [sceneId, models] of this.models) {
            stats.totalModels += models.length;
            stats.modelsByScene[sceneId] = models.length;
            
            models.forEach(model => {
                const size = model.size || 'medium';
                stats.modelsBySize[size]++;
            });
        }
        
        return stats;
    }
    
    /**
     * 验证模型配置的完整性
     * @param {Object} modelConfig - 模型配置
     * @returns {boolean} 是否有效
     */
    validateModelConfig(modelConfig) {
        const required = ['id', 'url', 'name'];
        return required.every(field => modelConfig.hasOwnProperty(field) && modelConfig[field]);
    }
    
    /**
     * 导出模型注册表配置（用于调试）
     * @returns {Object} 完整的模型配置
     */
    exportConfig() {
        const config = {};
        for (const [sceneId, models] of this.models) {
            config[sceneId] = models;
        }
        return config;
    }
    
    /**
     * 从配置导入模型注册表
     * @param {Object} config - 模型配置对象
     */
    importConfig(config) {
        this.models.clear();
        for (const [sceneId, models] of Object.entries(config)) {
            this.models.set(sceneId, models);
        }
        console.log('模型注册表配置已导入');
    }
}
